home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DBio / DSeqDoc.cpp < prev    next >
Text File  |  1996-07-05  |  40KB  |  1,510 lines
  1. // DSeqDoc.cp
  2.  
  3. #define ETEXT 1
  4.  
  5.  
  6. #include "DSeqDoc.h"
  7. #include <ncbi.h>
  8. #include <dgg.h>
  9. #include <Dvibrant.h>
  10. #include <DApplication.h>
  11. #include <DClipboard.h>
  12. #include <DControl.h>
  13. #include <DWindow.h>
  14. #include <DRichViewNu.h>
  15. #include <DTableView.h>
  16. #include <DViewCentral.h>
  17. #include <DTask.h>
  18. #include <DTracker.h>
  19. #include <DMenu.h>
  20. #include <DUtil.h>
  21. #include <DFindDlog.h>
  22. #include "DRichHandler.h"
  23. #include "DSeqFile.h"
  24. #include "DSeqEd.h"
  25. #include "DSeqMail.h"
  26. #include "DSeqCmds.h"
  27. #include "DSeqChildApp.h"
  28. #include "DSeqPrint.h"
  29. #include "DSeqPict.h"
  30. #include "DSeqViews.h"
  31.  
  32. //#include "DSeqAsmView.h"
  33.  
  34.  
  35.  
  36. Global char* gDefSeqName = NULL;
  37. static char gDefSeqNameStore[128];
  38. Boolean  DSeqDoc::fgTestSeqFile = false; // turn on/off seq-test for OpenDocument()
  39. Boolean  DSeqDoc::fgStartDoc = true;
  40. short         DSeqDoc::fgMatKind= 0;
  41. short         DSeqDoc::fgDistCor= 0;
  42. Boolean  DSeqDoc::fgLockText = false;  
  43. short         DSeqDoc::fgViewMode = DAlnView::kModeSlide;
  44. //Boolean  DSeqDoc::fgUseColor = false;  
  45. short         DSeqDoc::fgUseColor = DAlnView::kBaseColor;
  46. Nlm_RecT DSeqDoc::fgWinRect = { 0, 0, 0, 0 };
  47. char *     DSeqDoc::fgSire = "SPup";
  48.  
  49.  
  50.  
  51.  
  52. class DSeqFormatPopup : public DPopupList
  53. {
  54. public:
  55.     DSeqFormatPopup(long id, DView* superior, short defaultFormat);
  56.     virtual short GetValue() { return DSeqFile::kMinFormat + DPopupList::GetValue() - 1; }
  57. };
  58.  
  59. DSeqFormatPopup::DSeqFormatPopup(long id, DView* superior, short defaultFormat) :
  60.             DPopupList(id,superior,true)
  61. {
  62.     for (short i= DSeqFile::kMinFormat; i<=DSeqFile::kMaxFormat; i++) 
  63.         this->AddItem( (char*)DSeqFile::FormatName(i));
  64.     this->SetValue(defaultFormat);
  65. }
  66.  
  67.  
  68.  
  69. class DAlnModePopup : public DPopupList
  70. {
  71. public:
  72.     DAlnModePopup(long id, DView* superior, short defaultvalue);
  73.     virtual short GetValue() { return DAlnView::kModeSlide + DPopupList::GetValue() - 1; }
  74. };
  75.  
  76. DAlnModePopup::DAlnModePopup(long id, DView* superior, short defaultvalue) :
  77.             DPopupList(id,superior,true)
  78. {
  79.     AddItem( "Slide bases");
  80.     AddItem( "Edit bases");
  81.     AddItem( "Select mask 1");
  82.     AddItem( "Select mask 2");
  83.     AddItem( "Select mask 3");
  84.     AddItem( "Select mask 4");
  85.     this->SetValue(defaultvalue+1);
  86. }
  87.  
  88.  
  89. class DAlnColorPopup : public DPopupList
  90. {
  91. public:
  92.     DAlnColorPopup(long id, DView* superior, short defaultvalue);
  93.     virtual short GetValue() { return DAlnView::kBaseBlack + DPopupList::GetValue() - 1; }
  94. };
  95.  
  96. DAlnColorPopup::DAlnColorPopup(long id, DView* superior, short defaultvalue) :
  97.             DPopupList(id,superior,true)
  98. {
  99.     AddItem( "Black");
  100.     AddItem( "Color");
  101.     AddItem( "Align");
  102.     AddItem( "Back color");
  103.     AddItem( "Back align");
  104.     this->SetValue(defaultvalue +1 - DAlnView::kBaseBlack);
  105. }
  106.  
  107.  
  108.  
  109. // class DAlnFindDialog
  110.  
  111. class DAlnFindDialog : public DFindDialog {
  112. public:
  113.     DSequence* fSequence;
  114.     DAlnView* fAlnView;
  115.     short     fRow;
  116.     char    * fLastTarget;
  117.     long        fLastMatch;
  118.     DAlnFindDialog( DSequence* itsSeq, DAlnView* itsView);
  119.     virtual void DoFind();
  120.     virtual void BuildDlog();
  121. };
  122.  
  123. DAlnFindDialog::DAlnFindDialog( DSequence* itsSeq, DAlnView* itsView) :
  124.         fSequence(itsSeq), fAlnView( itsView), 
  125.         fLastTarget(NULL), fRow(-1), fLastMatch(-1)
  126. {
  127. }
  128.  
  129. void DAlnFindDialog::BuildDlog()
  130. {
  131.     DFindDialog::BuildDlog();
  132.  
  133.     DView* av;
  134.     av= FindSubview(replaceId); if (av) { av->Disable(); } //av->Hide();
  135.     av= FindSubview(replaceFindId); if (av) { av->Disable();  }
  136.     av= FindSubview(replaceAllId); if (av) { av->Disable(); }
  137.     av= FindSubview(cBackwards);     if (av) { av->Disable(); }
  138.     av= FindSubview(cFullWord); if (av) { av->Disable(); }
  139.     av= FindSubview(cCaseSense); if (av) { av->Disable(); }
  140.     if (fReplaceText) fReplaceText->Disable();
  141. }
  142.  
  143. void DAlnFindDialog::DoFind() 
  144. {
  145.     long    firstBase, nBases, match;
  146.     const char    *target;
  147.     Boolean back;
  148.     Nlm_RecT selr;
  149.     long        selrow;
  150.     
  151.     //fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  152.     fSequence= fAlnView->SelectedSequence(selrow);
  153.     fRow= selrow;
  154.     if (fSequence) {
  155.         fSequence->UpdateFlds();  
  156.         selr= fAlnView->GetSelRect();
  157.         selr.top= fRow;
  158.         selr.bottom= fRow+1; //??
  159.         firstBase= selr.left;
  160.         nBases= 0; //selr.right - firstBase;
  161.         fSequence->SetSelection( firstBase, nBases);
  162.         target= this->GetFind();
  163.         back    = this->Backwards();
  164.         if (target && *target) {
  165.             if (fLastTarget && (StringCmp(target, fLastTarget)==0) && firstBase == fLastMatch)
  166.                 match= fSequence->SearchAgain();
  167.             else {
  168.                 if (fLastTarget) MemFree(fLastTarget);
  169.                 fLastTarget= StrDup(target);
  170.                 match= fSequence->Search( (char*)target, back);
  171.                 }
  172.             fLastMatch= match;
  173.             if (match>=0) {
  174.                 nBases= StrLen(target);
  175.                 fSequence->SetSelection( match, nBases);
  176.                 selr.left= match;
  177.                 selr.right= match + nBases;
  178.                 fAlnView->SelectCells( selr);  
  179.                 if (fAlnView->fEditSeq && fAlnView->fEditRow == selrow)
  180.                     fAlnView->fEditSeq->Select(match, nBases);
  181.                 }
  182.             }
  183.         }
  184. }                
  185.  
  186.  
  187.  
  188. //class DSeqDoc
  189.  
  190.  
  191. DSeqDoc::DSeqDoc( long id, DSeqList* itsSeqList, char* name) :
  192.         DWindow( id, gApplication),
  193.         fAlnView(NULL), fAlnIndex(NULL), fAlnITitle(NULL),
  194.         fSeqList(itsSeqList), fPrintDoc(NULL),
  195.         fHeadline(NULL), fSeqMeter(NULL), fFormatPop(NULL),
  196.         fUpdateTime(0), fDocTitle(NULL),
  197.         fInFormat(DSeqFile::kGenBank), // kNoFormat
  198.         fSaveSelection(false),
  199.         //fLockButton(NULL), fColorButton(NULL), fMonoButton(NULL),
  200.         fColorCheck(NULL), fLockCheck(NULL),
  201.         fUseColor(false)
  202. { 
  203.     short width= -1, height= -1, left= -10, top= -20; // default window loc
  204.     if (gTextFont == NULL) gTextFont= Nlm_programFont;
  205.     if (gSeqFont == NULL) gSeqFont= Nlm_programFont;
  206.  
  207.     if (!Nlm_EmptyRect(&fgWinRect))  {
  208.             // these two are causing resize to fail >> width & height setting !!
  209.         //width= MAX( 40, fgWinRect.right - fgWinRect.left);
  210.         //height= MAX( 50, fgWinRect.bottom - fgWinRect.top);
  211.         left= MAX(20,fgWinRect.left);
  212.         top = MAX(40,fgWinRect.top);
  213.         }
  214.  
  215.     this->InitWindow( document, width, height, left, top, name); 
  216.     gDefSeqName= name; 
  217.     
  218.     if (!fSeqList) fSeqList= new DSeqList();  
  219.     //fSeqList->AddNewSeq();    // install 1 blank seq for new doc
  220. }
  221.  
  222.  
  223. DSeqDoc::~DSeqDoc()
  224. {
  225.     fAlnView->DeInstallEditSeq(); 
  226.     if (fSeqList) { 
  227.         //fSeqList->FreeAllObjects(); 
  228.         //fSeqList->suicide(); // need this for other users of list ??
  229.         fSeqList->fDeleteObjects= true; 
  230.         delete fSeqList; // knows how to delete
  231.         }
  232. }
  233.  
  234. void DSeqDoc::FreeData()
  235. {
  236.     fAlnView->DeInstallEditSeq(); 
  237.     if (fSeqList) { 
  238.         //fSeqList->FreeAllObjects(); // DaMN !! THIS IS NOT CALLING Seq Destructors !!
  239.         long i, n= fSeqList->GetSize();
  240.         for (i=0; i<n; i++) {
  241.             DSequence* aseq= fSeqList->SeqAt(i);
  242.             delete aseq;
  243.             }
  244.         fSeqList->DeleteAll();
  245.         }
  246. }
  247.  
  248.  
  249. Boolean DSeqDoc::IsSeqFile(DFile* aFile)
  250. {
  251.     // this is a static function, usable w/o a DGopherListDoc object
  252.     if (fgTestSeqFile && aFile && aFile->Exists()) {
  253.         aFile->OpenFile();
  254.         short format= DSeqFile::SeqFileFormatWrapper( aFile);
  255.         return (format != DSeqFile::kUnknown);
  256.         }
  257.     else
  258.         return false;
  259. }
  260.  
  261. void DSeqDoc::MakeGlobalsCurrent()
  262. {
  263.     ViewRect( fViewrect); // get current rect...
  264.     if (!Nlm_EmptyRect(&fViewrect)) fgWinRect= fViewrect;  
  265.     if (fLockCheck) fgLockText= fLockCheck->GetStatus();
  266.     //if (fColorCheck) fgUseColor= fColorCheck->GetStatus();
  267.     if (fColorPop) fgUseColor= fColorPop->GetValue();
  268.     if (fModePop) fgViewMode= fModePop->GetValue();
  269. }
  270.  
  271. void DSeqDoc::Close()
  272. {
  273. #if 1
  274.     DList* winlist= gWindowManager->GetWindowList();
  275.     short  i, nwin= winlist->GetSize();
  276.     for (i=0; i<nwin; i++) {
  277.         DWindow* awin= (DWindow*) winlist->At(i);
  278.         if (awin->Id() == DSeqedWindow::kId 
  279.             && ((DSeqedWindow*) awin)->fMainDoc == this) { 
  280.                 delete awin; // ?? or awin->Close();
  281.                  }
  282.         }
  283. #endif
  284.     
  285.     MakeGlobalsCurrent();
  286.     DWindow::Close();
  287. }
  288.  
  289. void DSeqDoc::ResizeWin()
  290. {
  291.     DWindow::ResizeWin();
  292.     MakeGlobalsCurrent();
  293. }
  294.  
  295. void DSeqDoc::Open(DFile* aFile)
  296. {
  297.     Boolean isempty= (fSeqList->GetSize() < 1);
  298.     if ( ReadFrom( aFile, true) ) {
  299.         if (isempty) {
  300.             this->SetTitle((char*)aFile->GetShortname());
  301.             this->SetFilename((char*)aFile->GetName());
  302.             }
  303.         this->Open();
  304.         }
  305.     else 
  306.         if (isempty) this->suicide();
  307. }
  308.  
  309.  
  310. void DSeqDoc::Revert()
  311. {
  312.     char buf[512];
  313.     char *name= GetFilename(buf, sizeof(buf));
  314.     DFile aFile(name);
  315.     fAlnView->DeInstallEditSeq(); 
  316.     if ( ReadFrom( &aFile, false) ) {
  317.         //this->Open();
  318.         DSaveHandler::NotDirty();
  319.         fAlnView->GetReadyToShow();  
  320.         fAlnView->Invalidate();
  321.         fAlnITitle->GetReadyToShow();
  322.         if (fAlnIndex){
  323.             fAlnIndex->GetReadyToShow();
  324.             fAlnIndex->Invalidate();
  325.             }
  326.         }
  327. }
  328.  
  329.  
  330. // static
  331. void DSeqDoc::NewSeqDoc()
  332. {
  333.     DSeqDoc* newdoc= new DSeqDoc( DSeqDoc::kSeqdoc, NULL, (char*)DFileManager::kUntitled);
  334.     newdoc->Open();
  335.     newdoc->EditSeqs(); //?? make it real obvious to beginners?
  336. }
  337.  
  338. // static
  339. void DSeqDoc::GetGlobals()
  340. {
  341.     char* onoffs;
  342.  
  343.     SeqDocPrefs(kSeqDocPrefInit);
  344.     DSeqPrintDoc::GetGlobals();
  345.     SeqPrintPrefs(kSeqPrintPrefInit);
  346.  
  347.     onoffs= (fgLockText) ? "1" : "0";
  348.     fgLockText= gApplication->GetPrefVal( "fgLockText", "windows", onoffs);
  349.     //onoffs= (fgUseColor) ? "1" : "0";
  350.     //fgUseColor= gApplication->GetPrefVal( "fgUseColor", "windows", onoffs);
  351.     fgUseColor= gApplication->GetPrefVal( "fgUseColor", "windows", "0");
  352.     fgViewMode= gApplication->GetPrefVal( "fgViewMode", "seqdoc", "0");
  353.     fgSire= gApplication->GetPref( "fgSire", "seqdoc", "SApp");
  354.     //DSeqFile::fgSire= fgSire; // messy !
  355.     //DSeqList::fgSire= fgSire; // messy !
  356.     DFile::fgSire= fgSire; // messy !
  357.     
  358.     {
  359.     //350, 200
  360.     char* srect = gApplication->GetPref( "fgWinRect", "windows", "30 40 450 220");
  361. #if 1
  362.         // sscanf is failing on Mac/codewar !! used to work
  363.     if (srect) {
  364.         char* cp= srect;
  365.         while (*cp && isspace(*cp)) cp++;
  366.         fgWinRect.left= atoi( cp);
  367.         
  368.         while (*cp && !isspace(*cp)) cp++;
  369.         while (*cp && isspace(*cp)) cp++;
  370.         fgWinRect.top= atoi( cp);
  371.         
  372.         while (*cp && !isspace(*cp)) cp++;
  373.         while (*cp && isspace(*cp)) cp++;
  374.         fgWinRect.right= atoi( cp);
  375.         
  376.         while (*cp && !isspace(*cp)) cp++;
  377.         while (*cp && isspace(*cp)) cp++;
  378.         fgWinRect.bottom= atoi( cp);
  379.         }
  380. #else
  381.         if (srect) sscanf( srect, "%d%d%d%d", &fgWinRect.left, &fgWinRect.top, 
  382.                                                 &fgWinRect.right, &fgWinRect.bottom);
  383. #endif
  384.         MemFree(srect);
  385.     }
  386. }
  387.  
  388. // static
  389. void DSeqDoc::SaveGlobals()
  390. {
  391.     gApplication->SetPref( (int) fgLockText,"fgLockText","windows");
  392.     gApplication->SetPref( (int) fgUseColor, "fgUseColor","windows");
  393.     gApplication->SetPref( (int) fgViewMode, "fgViewMode","seqdoc");
  394.     gApplication->SetPref( fgSire, "fgSire","seqdoc");
  395.  
  396.     if (!Nlm_EmptyRect(&fgWinRect)) {
  397.         char  srect[128];
  398.         sprintf( srect, "%d %d %d %d", fgWinRect.left, fgWinRect.top, 
  399.                                                         fgWinRect.right, fgWinRect.bottom);
  400.         gApplication->SetPref( srect, "fgWinRect", "windows");
  401.         }
  402. }
  403.  
  404.  
  405. void DSeqDoc::AddAlnIndex(DView* super, short width, short height)
  406. {
  407.     fAlnIndex= new DAlnIndex(0, super, this, fSeqList, width, height); 
  408. }
  409.  
  410. void DSeqDoc::AddAlnView(DView* super, short width, short height)
  411. {
  412.     fAlnView= new DAlnView(0, super, this, fSeqList, width, height); 
  413. }
  414.  
  415. void DSeqDoc::AddModePopup(DView* super)
  416. {
  417.     fModePop= new DAlnModePopup(kModePopup, super, fgViewMode);
  418. }
  419.  
  420. void DSeqDoc::AddTopViews(DView* super)
  421. {
  422.     DPrompt* pr;
  423.  
  424.     pr= new DPrompt(0,super,"Color:",0, 0, Nlm_programFont);
  425.     super->NextSubviewToRight();
  426.     fColorPop= new DAlnColorPopup(kColorPopup,super,fgUseColor);
  427.     fUseColor= fgUseColor;
  428.     super->NextSubviewToRight();
  429.  
  430.     pr= new DPrompt(0,super," View:",0, 0, Nlm_programFont);
  431.                     
  432.     super->NextSubviewToRight();
  433.     this->AddModePopup(super); 
  434.     fLockCheck= NULL;
  435.  
  436.     super->NextSubviewToRight();
  437.     pr= new DPrompt(0,super,"  File format:",0, 0, Nlm_programFont);
  438.  
  439.     DCluster* metergrp= new DCluster( 0, this, 0, 0, true);   // was 0,0 for w,h
  440.     pr= new DPrompt(0,metergrp,"Base#",0, 0, Nlm_programFont);
  441.     metergrp->NextSubviewToRight();
  442.     fSeqMeter= new DPrompt(0,metergrp,"0000000",0,0,Nlm_programFont,justright); //60,14
  443.  
  444.     super->NextSubviewToRight();
  445.     fFormatPop= new DSeqFormatPopup(0,super,fInFormat);
  446.     super->NextSubviewBelowLeft();
  447. }
  448.  
  449.  
  450. void DSeqDoc::AddViews()
  451. {
  452.     DView* super;
  453.     short width, height;
  454.     Nlm_PoinT        nps;
  455.     DPrompt* pr;
  456.     
  457.     if (!fAlnView || !fAlnIndex || !fAlnHIndex || !fAlnITitle) {
  458.         super= this;
  459.         
  460.         AddTopViews( super);
  461.  
  462.             // left group : titleline over name table
  463.         DCluster* grouper= new DCluster( 0, this, 0, 0, true);   // was 0,0 for w,h
  464.         grouper->SetResize( DView::fixed, DView::relsuper);
  465.         super= grouper;
  466.  
  467.         fAlnITitle= new DAlnITitle(0, super, 80, Nlm_stdLineHeight);
  468.         super->NextSubviewBelowLeft();
  469.  
  470.         //width= 350; height= 200;
  471.         super->GetNextPosition( &nps);
  472.         width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  473.         height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y;   
  474.         
  475.         this->AddAlnIndex( super, 80, height);
  476.  
  477.         super= this;
  478.         super->NextSubviewToRight();    
  479.      
  480.         super->GetNextPosition( &nps);
  481.         nps.x += 3;
  482.         super->SetNextPosition( nps);
  483.  
  484.             // right group : index topline over bases table
  485.         grouper= new DCluster( 0, this, 0, 0, true); // was 0,0 wid,hgt
  486.         grouper->SetResize( DView::relsuper, DView::relsuper);
  487.         super= grouper;
  488.         super->GetNextPosition( &nps);
  489.         width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  490.         height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y; 
  491.         fAlnHIndex= new DAlnHIndex(0, super, this, fSeqList, width, Nlm_stdLineHeight);
  492.         super->NextSubviewBelowLeft();
  493.         
  494.         //width= 350; height= 200;
  495.         super->GetNextPosition( &nps);
  496.         width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  497.         height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y; 
  498.         this->AddAlnView( super, width, height);
  499.         fAlnView->SetTextLock( fgLockText);
  500.         super= this;
  501.  
  502. #if ETEXT
  503.         //if (gLastEditView) gLastEditView->DeInstallEditSeq();
  504.         {
  505.         short charwidth= 0;
  506.     Nlm_PoinT  nps, saveps;
  507.         GetNextPosition( &saveps);
  508.         nps.x= 1; nps.y= 1; // locate dialog item 
  509.         SetNextPosition( nps);
  510.         //gDialogTextMultiline= false;
  511.  
  512.         charwidth= width / fAlnView->GetItemWidth();
  513.  
  514.         DAlnSequence* eseq= new DAlnSequence( 0, fAlnView, charwidth);  
  515.         fAlnView->fEditSeq= eseq;
  516.         //this->SetEditText(eseq);
  517.         eseq->fVisible= true;
  518.         eseq->HideEdit(); // eseq->Disable(); eseq->Hide();
  519.         this->SetEditText(NULL);  
  520.         SetNextPosition( saveps);
  521.         }
  522. #endif
  523.         }
  524.         
  525.     if (!fFindDlog) fFindDlog= new DAlnFindDialog( NULL, (DAlnView*)fAlnView);
  526. }
  527.  
  528.  
  529.  
  530. void DSeqDoc::Open()
  531. {
  532.     Boolean selectone= false;
  533.     
  534.     if (!fSeqList) fSeqList= new DSeqList();
  535.     if (fSeqList->GetSize() == 0) {
  536.         fSeqList->AddNewSeq();    // install 1 blank seq for new doc
  537.         selectone= true;
  538.         }
  539.     
  540.     AddViews();
  541.     fSaveHandler= this;  
  542.     fPrintHandler= this; 
  543.  
  544.     this->Select(); // for motif
  545. #if 0
  546.     fAlnView->GetReadyToShow(); // do before others ...
  547.     if (fAlnIndex) fAlnIndex->GetReadyToShow();
  548.     fAlnITitle->GetReadyToShow();
  549.  
  550.     if (0) {
  551.             // try auto-sizing aln view to data
  552.             //long ns= fSeqList->GetSize();
  553.     long ht = 0, nrow= fAlnView->GetMaxRows();
  554.     if (nrow > 2) {
  555.         ht = 80 + fAlnITitle->GetItemHeight(0);  
  556.         if (nrow > 25) nrow= 25; // max size?
  557.         for (long i= 0; i<nrow; i++) ht += fAlnView->GetItemHeight(i);
  558.         Nlm_RecT r;
  559.         GetPosition(r);
  560.         r.bottom = r.top + ht;
  561.         SetPosition(r);
  562.         }
  563.     }
  564.     this->CalcWindowSize();
  565.  
  566. #else
  567.     this->CalcWindowSize();
  568.     fAlnView->GetReadyToShow(); // do before others ...
  569.     if (fAlnIndex) fAlnIndex->GetReadyToShow();
  570.     fAlnITitle->GetReadyToShow();
  571.     //fAlnHIndex->GetReadyToShow();
  572.  
  573. #endif
  574.  
  575.     fAlnView->SetViewColor(fgUseColor);
  576.     fAlnView->SetViewMode(fgViewMode);
  577.     if (selectone && fAlnIndex) fAlnIndex->SelectCells(0,0);
  578.     fSeqMeter->Show();  
  579.     
  580.     DWindow::Open();
  581. }
  582.  
  583.  
  584. void DSeqDoc::Activate()
  585. {
  586.     if (fAlnView && fAlnView->fEditSeq && fAlnView->fEditSeq->fVisible) 
  587.         fAlnView->fEditSeq->selectAction();
  588.     gCursor->arrow();
  589.     DWindow::Activate();
  590. }
  591.  
  592. void DSeqDoc::Deactivate()
  593. {
  594.     if (fAlnView && fAlnView->fEditSeq) fAlnView->fEditSeq->deselectAction();
  595.     DWindow::Deactivate();
  596. }
  597.  
  598. void DSeqDoc::Print()
  599. {
  600.     // fix this to print more of window !
  601.     //fAlnView->Print();
  602.     
  603.     // or do prettyprint...
  604.     MakeSeqPrint( false);
  605.     fPrintDoc->PrintDoc();
  606. }
  607.  
  608. Boolean DSeqDoc::IsMyTask(DTask* theTask) 
  609. {
  610. #if 0
  611.     if (theTask->fKind == kSeqDoc) {
  612.         ProcessTask( theTask);
  613.         return true;
  614.         }
  615.     else 
  616. #endif
  617.         return DWindow::IsMyTask(theTask);
  618. }
  619.  
  620. void DSeqDoc::ProcessTask(DTask* theTask) 
  621. {
  622.     if (theTask->fNumber == -987654) {
  623.  
  624.         }
  625.     else {
  626.         DWindow::ProcessTask(theTask);
  627.         }
  628. }
  629.  
  630.  
  631. void DSeqDoc::SortView(DSeqList::Sorts sortorder)
  632. {
  633.     fSeqList->SortList(sortorder);
  634.     fAlnView->Invalidate();
  635.     if (fAlnIndex) fAlnIndex->Invalidate();
  636. }
  637.  
  638.  
  639. void DSeqDoc::AddSeqToList(DSequence* item)
  640. {
  641.     fAlnView->addToAlnList( item);
  642.     //fAlnView->SelectCells( fAlnView->GetMaxRows()-1, fAlnView->GetMaxCols());
  643.     if (fAlnIndex) fAlnIndex->SelectCells( fAlnView->GetMaxRows()-1, 0); 
  644. #if 0
  645.     this->Changed( 1, this);
  646. #endif
  647. }    
  648.  
  649.  
  650.  
  651. void DSeqDoc::AddNewSeqToList()
  652. {
  653.     DSequence* aSeq = new DSequence(); 
  654.     AddSeqToList( aSeq);
  655. }
  656.  
  657.  
  658. void DSeqDoc::FirstSelection( DSequence*& aSeq, long& start, long& nbases)
  659. {    
  660.     long            left, right, top, bottom, atRow;
  661.  
  662.     start= nbases= atRow= 0;
  663.     fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  664.     fAlnView->GetFirstSelectedCell(top,left);
  665.     fAlnView->GetLastSelectedCell(bottom,right);
  666.     
  667.     if (left !=  DTabSelection::kNoSelection && top !=  DTabSelection::kNoSelection 
  668.      && (left != right || top != bottom)) {
  669.       atRow = top;
  670.         start = left; // - 1;
  671.         nbases= right - start;  
  672.         }    
  673.     else if (fAlnIndex && fAlnIndex->IsSelected()) {
  674.         fAlnIndex->GetFirstSelectedCell(top,left);
  675.         fAlnIndex->GetLastSelectedCell(bottom,right);
  676.         atRow= top;
  677.         start= 0; 
  678.         nbases= 0; //key for all of seq
  679.         }    
  680.  
  681.     aSeq= fAlnView->SeqAt( atRow);
  682.     if (aSeq) {
  683.         aSeq->SetIndex(atRow);
  684.         aSeq->SetSelection( start, nbases);
  685.         }
  686. }
  687.  
  688. void DSeqDoc::AddSeqAtToList( long aRow, long start1, long nbases1, 
  689.                                                         DSeqList*& aSeqList, long& start, long& nbases)
  690. {
  691.     DSequence* aSeq= fAlnView->SeqAt( aRow); 
  692.     if (aSeq) {
  693.         aSeq->SetIndex( aRow);
  694.         aSeq->SetSelection( start1, nbases1);
  695.         aSeqList->InsertLast( aSeq);
  696.         start= Max(start,start1);
  697.         if (nbases==0) nbases= nbases1;
  698.         else nbases= Min(nbases,nbases1);
  699.         }
  700. }
  701.  
  702. void DSeqDoc::AddMaskedSeqToList( long aRow, short masklevel,
  703.                                     DSeqList*& aSeqList, long& start, long& nbases)
  704. {
  705.     DSequence* aSeq= fAlnView->SeqAt( aRow); 
  706.     if (aSeq && aSeq->MasksOk()) {
  707.         aSeq->ClearSelection();
  708.         aSeq= aSeq->CompressFromMask(masklevel);
  709.             // !! NOTE these Seqs are NEW -- delete when aSeqList is deleted
  710.         if (!aSeq) return;
  711.         if (aSeq->LengthF() == 0) { delete aSeq; return; }
  712.         aSeq->SetIndex( aRow);
  713.         aSeqList->InsertLast( aSeq);
  714.         aSeqList->fDeleteObjects= true;  // so NEW seqs are deleted
  715.         start= 0;
  716.         if (nbases==0) nbases= aSeq->LengthF();
  717.         else nbases= Min(nbases,aSeq->LengthF());
  718.         }
  719. }
  720.  
  721. #if 0
  722. enum  selectforms { 
  723.     kSeqSel = 1, kNoSeqSel = 0,
  724.     kMaskSel = 2, kNoMaskSel= 0,
  725.     kIndexSel = 4, kNoIndexSel = 0,
  726.     kAllIfNone = 8, kNoneIfNone = 0,
  727.     kEqualCount = 16, kUnequalCount = 0,
  728.     };
  729.   // kSeqSel+kMaskSel+kIndexSel+kAllIfNone+kEqualCount
  730. #endif
  731.   
  732. void DSeqDoc::GetSelection( long selectFlags, DSeqList*& aSeqList, long& start, long& nbases)
  733. // GetSelection(Boolean equalCount, Boolean allAtNoSelection,
  734. {
  735.     long            left, right, top, bottom, arow, acol;
  736.     long            start1, nbases1;
  737.     Boolean        equalCount, allAtNoSelection, useSeqSelection, useMasks;
  738.  
  739.     equalCount = (selectFlags & kEqualCount);
  740.     allAtNoSelection = (selectFlags & kAllIfNone);
  741.     useMasks = (selectFlags & kMaskSel);
  742.     useSeqSelection = (selectFlags & kSeqSel);
  743.     
  744.     fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  745.     start= 0; start1= 0;
  746.     nbases= 0; nbases1= 0;
  747.     aSeqList= new DSeqList();
  748.     useMasks= useMasks && (fAlnView->fMaskLevel > 0);
  749.     
  750.     fAlnView->GetFirstSelectedCell(top,left);
  751.     fAlnView->GetLastSelectedCell(bottom,right);
  752.     useSeqSelection = useSeqSelection && (!useMasks 
  753.             && left != DTabSelection::kNoSelection 
  754.             && top != DTabSelection::kNoSelection 
  755.              && (left != right || top != bottom));
  756.     
  757. #if 0
  758.         // THIS IS STILL BUGGY -- need to TEST & FIX
  759.     if (useMasks && fAlnView->IsMasked()) {
  760.         top= 0;
  761.         bottom= fSeqList->GetSize();
  762.         if (fAlnIndex && fAlnIndex->IsSelected()) {
  763.             fAlnIndex->GetFirstSelectedCell(top,left);
  764.             fAlnIndex->GetLastSelectedCell(bottom,right);
  765.             }
  766.         for (arow= top; arow<bottom; arow++)  
  767.             AddMaskedSeqToList( arow, fAlnView->fMaskLevel, 
  768.                                                         aSeqList, start, nbases);
  769.         }        
  770.     else 
  771. #endif
  772.  
  773.     if (useSeqSelection) {
  774.         for (arow= top; arow<bottom; arow++) {
  775.             if (equalCount) acol= left; else acol= 0; 
  776.             
  777.             while (acol<right && !fAlnView->IsSelected(arow,acol)) acol++;
  778.             start1= acol; // - 1;
  779.             if (equalCount)
  780.                 while (acol<right && fAlnView->IsSelected(arow,acol)) acol++;
  781.             else 
  782.                 while (fAlnView->IsSelected(arow,acol)) acol++;
  783.             nbases1= acol - start1;
  784.             
  785.             AddSeqAtToList( arow, start1, nbases1, aSeqList, start, nbases);
  786.             }
  787.         start = left; // - 1;
  788.         nbases= right - start;  
  789.         }    
  790.         
  791.     else if (fAlnIndex && fAlnIndex->IsSelected()) {
  792.         fAlnIndex->GetFirstSelectedCell(top,left);
  793.         fAlnIndex->GetLastSelectedCell(bottom,right);
  794.         for (arow= top; arow<bottom; arow++) 
  795.             AddSeqAtToList( arow, start1, nbases1, aSeqList, start, nbases);
  796.         }    
  797.         
  798.     else if (allAtNoSelection) {
  799.          for (arow= 0; arow<fSeqList->GetSize(); arow++) 
  800.             AddSeqAtToList( arow, start1, nbases1, aSeqList, start, nbases);
  801.         }
  802. }
  803.             
  804.  
  805. short DSeqDoc::SelectionToFile(Boolean AllatNoSelection, char* aFileName, short seqFormat)  
  806. {
  807.     long        start, nbases;
  808.     long        nseqs;
  809.     DSeqList *aSeqList;
  810.  
  811.     GetSelection( kSeqSel+kMaskSel+kIndexSel+kAllIfNone, aSeqList, start, nbases);
  812.     nseqs= aSeqList->GetSize();
  813.     aSeqList->DoWrite( aFileName, seqFormat); 
  814.     delete aSeqList;
  815.     return nseqs;
  816. }
  817.  
  818.  
  819. void DSeqDoc::NotDirty()
  820. {
  821.     DSaveHandler::NotDirty();
  822.     long i, nseqs= fSeqList->GetSize();
  823.     for (i=0; i<nseqs; i++) {
  824.         fSeqList->SeqAt(i)->SetChanged(false);
  825.         }
  826.     if (fAlnIndex) fAlnIndex->Invalidate();
  827. }  
  828.  
  829.  
  830. void DSeqDoc::WriteTo(DFile* aFile)  
  831. {
  832.     short outformat= DSeqFile::kGenBank;
  833.     if (fFormatPop) outformat= fFormatPop->GetValue(); 
  834.     fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  835.     if (fSaveSelection) {
  836.         long        start, nbases;
  837.         DSeqList* aSeqList= NULL;
  838.         fSaveSelection= false;
  839.         GetSelection( kSeqSel+kMaskSel+kIndexSel+kAllIfNone, aSeqList, start, nbases);
  840.         aSeqList->DoWrite( aFile, outformat);
  841.         delete aSeqList;
  842.         }    
  843.     else {
  844.         fSeqList->ClearSelections(); //! make sure we write all of seq from this call !?
  845.         fSeqList->DoWrite( aFile, outformat);
  846.         this->NotDirty();  
  847.         }
  848. }
  849.  
  850.  
  851.  
  852.  
  853.  
  854. Boolean DSeqDoc::ReadFrom(DFile* aFile, Boolean append)    // revise for iostreams
  855. {
  856.     if (!append) FreeData();   //?? or leave here for append...
  857.     gDefSeqName= this->GetTitle(gDefSeqNameStore,sizeof(gDefSeqNameStore));
  858.     fInFormat= DSeqFile::ReadSeqFile(aFile, fSeqList);  
  859.     return true; //?? (fInFormat != DSeqFile::kUnknown)
  860. }
  861.  
  862.  
  863.  
  864.  
  865. void DSeqDoc::OpenSeqedWindow(DSequence* aSeq)
  866. {
  867.     char* title= StrDup( aSeq->Name());
  868.     StrExtendCat( &title, " Edit");
  869.     DSeqedWindow* edwin = new DSeqedWindow( DSeqedWindow::kId, gApplication, 
  870.                                                 this, aSeq, -5, -5, -50, -20, title);
  871.     MemFree( title);
  872.     edwin->Open(); 
  873.     edwin->Select();     
  874. }
  875.  
  876.  
  877.  
  878. void DSeqDoc::EditSeqs() 
  879. {
  880.     DSequence* aSeq= fAlnView->SelectedSequence();  
  881.     if (aSeq) this->OpenSeqedWindow(aSeq);
  882. }
  883.  
  884.  
  885.  
  886.  
  887. void DSeqDoc::ToTextDoc()
  888. {
  889.     DTempFile* tmpFile= new DTempFile();
  890.     this->WriteTo(tmpFile);
  891.     DRichTextDoc* doc= new DRichTextDoc(0,  true, gTextFont);
  892.     doc->Open(tmpFile);
  893.     delete tmpFile;
  894. }
  895.  
  896.  
  897. void DSeqDoc::MakeSeqPrint(Boolean doREMap)
  898. {
  899.     long        firstbase, nbases;
  900.     DSeqList* aSeqList= NULL;
  901.     fSaveSelection= false;
  902.     DWindow    * aDoc;
  903.     
  904.     GetSelection( kSeqSel+kMaskSel+kIndexSel+kAllIfNone, //+kEqualCount??
  905.                                 aSeqList, firstbase, nbases);
  906.     if (!aSeqList)
  907.         return;
  908.     else if (doREMap) {
  909.         aDoc = new DREMapPrintDoc( DSeqPrintDoc::kSeqPrintDoc, this, aSeqList, firstbase, nbases);
  910.         aDoc->Open();  
  911.         }
  912.     else if (aSeqList->GetSize() > 1) {
  913.         aDoc = new DAlnPrintDoc( DSeqPrintDoc::kSeqPrintDoc, this, aSeqList, firstbase, nbases);
  914.         aDoc->Open();  
  915.         }        
  916.     else {
  917.         aDoc = new DSeqPrintDoc( DSeqPrintDoc::kSeqPrintDoc, this, aSeqList, firstbase, nbases);
  918.         aDoc->Open();  
  919.         }
  920.     fPrintDoc= aDoc;
  921. }
  922.  
  923. void DSeqDoc::MakeAlnPrint()
  924. {
  925.     MakeSeqPrint(false);
  926. }
  927.  
  928.  
  929.  
  930. void DSeqDoc::SetUpMenu(short menuId, DMenu*& aMenu) 
  931. {
  932.     //DWindow::SetUpMenu(menuId, aMenu);
  933.  
  934.     if (menuId == kSeqMenu) {
  935.         if (!aMenu) aMenu = gApplication->NewMenu( menuId, "Sequence");
  936.         //aMenu->AddItem( cSeqPrefs, "Seq Prefs...");    
  937.     
  938.         aMenu->AddItem( cNewSeq, "New sequence");
  939.         aMenu->AddItem( cEditSeq, "Edit seq...");
  940.      
  941.         DMenu* vMenu= new DSubMenu( kViewKindMenu, aMenu, "View seqs");
  942.         vMenu->AddItem( kViewByDefault, "default");
  943.         vMenu->AddItem( kViewByDate, "by Date");
  944.         vMenu->AddItem( kViewBySize, "by Size");
  945.         vMenu->AddItem( kViewByName, "by Name");
  946.         vMenu->AddItem( kViewByKind, "by Kind");
  947.         vMenu->AddItem( kViewAsText, "as Text");
  948.  
  949.         DMenu* mMenu= new DSubMenu( kSeqMaskMenu, aMenu, "Seq mask");
  950.         mMenu->AddItem(cMaskSelAll,"Mask all",false, true);
  951.         mMenu->AddItem(cMaskInvert,"Invert mask",false, true);
  952.         mMenu->AddItem(cMaskClear,"Clear mask",false, true);
  953.         mMenu->AddSeparator();
  954.  
  955.         mMenu->AddItem(cSel2Mask,"Selection to Mask",false, true);
  956.         mMenu->AddItem(cMask2Sel,"Mask to Selection",false, true);
  957.         mMenu->AddItem(cMaskOrSel,"Mask OR Selection",false, true);
  958.         mMenu->AddItem(cMaskAndSel,"Mask AND Selection",false, true);
  959.         //gViewCentral->DisableView(cMask2Sel);
  960.         //gViewCentral->DisableView(cMaskOrSel);
  961.         //gViewCentral->DisableView(cMaskAndSel);
  962.         mMenu->AddSeparator();
  963.         mMenu->AddItem(cMaskCompress, "Compress by mask");
  964.         mMenu->AddItem(cMaskSelCommon,"Mask consensus",false, true);
  965.         mMenu->AddItem(cMaskSelORF,"Mask ORFs",false, true);
  966.         mMenu->AddItem(cMaskReplicate,"Replicate mask to all seqs",false, true);
  967.  
  968.         aMenu->AddSeparator();
  969.         aMenu->AddItem( cRevSeq, "Reverse");
  970.         aMenu->AddItem( cCompSeq, "Complement");
  971.         aMenu->AddItem( cRevCompSeq, "Rev-Compl");
  972.         aMenu->AddItem( cDna2Rna, "Dna->Rna");
  973.         aMenu->AddItem( cRna2Dna, "Rna->Dna");
  974.         aMenu->AddItem( cToUpper, "UPPER Case");
  975.         aMenu->AddItem( cToLower, "lower Case");
  976.  
  977.         aMenu->AddItem( cDegap, "Degap");
  978.         aMenu->AddItem( cLockIndels, "Lock indels");
  979.         aMenu->AddItem( cUnlockIndels, "Unlock indels");
  980.         aMenu->AddItem( cConsensus, "Consensus");
  981.         aMenu->AddItem( cTranslate, "Translate");
  982.         aMenu->AddItem( cDistance, "Distance");
  983.         //aMenu->AddItem( cSimilarity, "Similarity");
  984.  
  985.         aMenu->AddSeparator();
  986.         aMenu->AddItem( cPrettyPrint, "Pretty Print...");
  987.         aMenu->AddItem( cREMap, "Restriction map...");
  988.         aMenu->AddItem( cDotPlot, "Dot plot...");
  989.         gViewCentral->DisableView(cDotPlot);
  990.  
  991.         aMenu->AddSeparator();        
  992.         aMenu->AddItem( cNAcodes, "Nucleic codes...");
  993.         aMenu->AddItem( cAAcodes, "Amino codes...");
  994.          }
  995.      
  996.     else if (menuId == DApplication::cEditMenu) {
  997.         aMenu->AddSeparator();
  998.         aMenu->AddItem(DApplication::kFind,"Find.../F",false, true);
  999.         aMenu->AddItem(DApplication::kFindAgain,"Find again/G",false, true);
  1000.         aMenu->AddItem(cFindORF,"Find ORF/R",false, true);
  1001.  
  1002.         }
  1003.         
  1004.      else if (menuId == kInternetMenu) {
  1005.         if (!aMenu) aMenu = gApplication->NewMenu( menuId, "Internet");
  1006.         aMenu->AddItem( 0, "[Mail servers]");
  1007.         aMenu->AddItem( cNCBIfetch, "NCBI fetch...");
  1008.         aMenu->AddItem( cNCBIblast, "NCBI BLAST search...");
  1009.         aMenu->AddItem( cEMBLfetch, "EMBL fetch...");
  1010.         aMenu->AddItem( cEMBLquicks, "EMBL Quicksearch...");
  1011.         aMenu->AddItem( cEMBLfasta, "EMBL FastA search...");
  1012.         aMenu->AddItem( cEMBLblitz, "EMBL Blitz search...");
  1013.         aMenu->AddItem( cFHCRCfetch, "FHCRC fetch...");
  1014.         aMenu->AddItem( cFHCRCblocks, "FHCRC Blocks search...");
  1015.         aMenu->AddItem( cGeneidSearch, "Geneid search...");
  1016.         aMenu->AddItem( cGrailSearch, "Grail search...");
  1017.         //aMenu->AddItem( cGenmarkSearch, "Genmark search...");
  1018.         //aMenu->AddItem( cPythiaSearch, "Pythia search...");
  1019.          //aMenu->AddSeparator();    
  1020.          }                            
  1021.  
  1022. }
  1023.  
  1024.  
  1025.  
  1026.  
  1027. char* DSeqDoc::GetTitle(char* title, ulong maxsize) 
  1028. { 
  1029.     if (fSaveSelection) {
  1030.         if (title==NULL) title= (char*) MemNew(maxsize); 
  1031.         DWindow::GetTitle( title, maxsize); 
  1032. #ifdef OS_DOS
  1033.         DFileManager::ReplaceSuffix( title, maxsize, ".sel");
  1034. #else
  1035.         StrNCat( title,".part", maxsize); 
  1036. #endif
  1037.         return title;
  1038.         }
  1039.     else if (fDocTitle && *fDocTitle) {
  1040.         if (title==NULL) {
  1041.             maxsize= Min(maxsize,StrLen(fDocTitle)+1);
  1042.             title= (char*) MemNew(maxsize); 
  1043.             }
  1044.         StrNCpy(title,fDocTitle,maxsize);
  1045.         return title;
  1046.         }
  1047.     else {
  1048.         DWindow::GetTitle( title, maxsize);
  1049.         //if (StringCmp(title,kUntitled)==0) *title= 0; // set to null so saveas is called
  1050.         return title;
  1051.         }
  1052. }
  1053.  
  1054. void DSeqDoc::FindORF()
  1055. {
  1056.     long    start, stop;
  1057.     DSequence* aSeq;
  1058.     long            selrow= 0;
  1059.     Nlm_RecT    selr;
  1060.     
  1061.     aSeq= fAlnView->SelectedSequence(selrow);
  1062.     if (aSeq) {
  1063.         selr= fAlnView->GetSelRect();
  1064.         if (selr.right > selr.left+1) selr.left++; // !? offset sel start so we can repeat call
  1065.         selr.top= selrow;
  1066.         selr.bottom= selrow+1; 
  1067.         aSeq->SetSelection( selr.left, 0);
  1068.         aSeq->SearchORF( start, stop);
  1069.         if (start>=0) {
  1070.             if (stop<start) stop= aSeq->LengthF(); //??
  1071.             aSeq->SetSelection( start, stop - start);
  1072.             selr.left= start;
  1073.             selr.right= stop;
  1074.             fAlnView->SelectCells( selr);
  1075.             if (fAlnView->fEditSeq && fAlnView->fEditRow == selrow)
  1076.                 fAlnView->fEditSeq->Select(start, stop - start);
  1077.             }
  1078.         } 
  1079. }
  1080.  
  1081.  
  1082. void DSeqDoc::MakeConsensus()
  1083. {
  1084.     long    firstBase = 0, nBases = 0;
  1085.     DSeqList * aSeqList= NULL;
  1086.     DSequence* cons;
  1087.     
  1088.     GetSelection( kSeqSel+kMaskSel+kIndexSel+kAllIfNone+kEqualCount, 
  1089.                                 aSeqList, firstBase, nBases);
  1090.     if (aSeqList) {
  1091.         cons= fSeqList->Consensus();
  1092.         if (cons) {
  1093.             long aRow, totalRows;
  1094.             Nlm_RecT    r;
  1095.             aRow= fSeqList->GetIdentityItemNo( cons);
  1096.             totalRows= fSeqList->GetSize();
  1097.             fSeqList->Delete(cons);
  1098.             delete cons;
  1099.             fAlnView->GetRowRect( aRow, r, totalRows-aRow+1);
  1100.             fAlnView->InvalRect( r);
  1101.             if (fAlnIndex) {
  1102.                 fAlnIndex->GetRowRect( aRow, r, totalRows-aRow+1);
  1103.                 fAlnIndex->InvalRect( r);
  1104.                 }
  1105.             fAlnView->UpdateSize();   
  1106.             }
  1107.             
  1108.         aSeqList->MakeConsensus();
  1109.         cons= aSeqList->Consensus();
  1110.         if (cons) {
  1111.             AddSeqToList( cons);
  1112.             //if (fAlnIndex) fAlnIndex->SelectCells( fSeqList->ConsensusRow(), 0); 
  1113.             //fAlnIndex->ScrollSelectionIntoView(TRUE);
  1114.             }
  1115.         delete aSeqList;
  1116.         }
  1117. }
  1118.  
  1119. void DSeqDoc::DistanceMatrix(short form)
  1120. {
  1121.     long    firstBase = 0, nBases = 0;
  1122.     DSeqList * aSeqList= NULL;
  1123.     short correction= fgDistCor; //DSeqList::DCnone; //DCnone, DCjukes, DColsen 
  1124.     char  title[128];
  1125.     
  1126.     this->GetTitle(title, sizeof(title));
  1127.     
  1128.     GetSelection( kSeqSel+kMaskSel+kIndexSel+kAllIfNone+kEqualCount, 
  1129.                                 aSeqList, firstBase, nBases);
  1130.     if (aSeqList) {            
  1131.         char* dmat = NULL;
  1132.         switch (form) {
  1133.             case 1: 
  1134.                 DFileManager::ReplaceSuffix(title, sizeof(title), ".Similarities");
  1135.                 dmat= aSeqList->Similarities(correction);  
  1136.                 break;
  1137.             case 0: 
  1138.             default:
  1139.                 DFileManager::ReplaceSuffix(title, sizeof(title), ".Distances");
  1140.                 dmat= aSeqList->Distances(correction); 
  1141.                 break;
  1142.             }
  1143.             
  1144.         if (dmat) {
  1145.             DRichTextDoc* doc= new DRichTextDoc();
  1146.             doc->fRichView->fDocFormat= DRichHandler::kTextformat;
  1147.             doc->SetTitle(title);
  1148.             doc->OpenText( dmat);
  1149.             }
  1150.         delete aSeqList;
  1151.         }
  1152. }
  1153.  
  1154.  
  1155. #if NETBLAST
  1156. extern "C" short CallNCBIBlastService( char* blastProgram, char* blastDatabase, char* blastOptions, 
  1157.                                                      char* fastaInputFile, char* outputFile );
  1158.  
  1159. void DSeqDoc::BLASTdialog()
  1160. {
  1161.     char* blastProgram = "blastn";
  1162.     char* blastDatabase = "nr";
  1163.     char* blastOptions = NULL;
  1164.     char* fastaInputFile = "spup-blast-input.fasta";
  1165.     char* outputFile = "spup-blast-result.text";
  1166.     char    instore[128];
  1167.     char  outstore[128];
  1168.     DFile aFile;
  1169.             
  1170.     fastaInputFile= DFileManager::TempFilename( instore);
  1171.     outputFile= DFileManager::TempFilename( outstore);
  1172.  
  1173.     short nseq= SelectionToFile( false, fastaInputFile, DSeqFile::kPearson);
  1174.     if (nseq) {
  1175.         short err= CallNCBIBlastService(blastProgram, blastDatabase, blastOptions, 
  1176.                                                 fastaInputFile, outputFile);
  1177.  
  1178.         if (err) {
  1179.             Message(MSG_OK,"DSeqDoc::CallNCBIBlastService error %d", err);
  1180.             }
  1181.         else {
  1182.             DRichTextDoc* doc= new DRichTextDoc(0,  true, gTextFont);
  1183.             doc->Open(outputFile);
  1184.             aFile.Initialize(outputFile);
  1185.             aFile.Delete();
  1186.             }
  1187.          }
  1188.     aFile.Initialize(fastaInputFile);
  1189.     aFile.Delete();
  1190. }
  1191. #endif
  1192.  
  1193.  
  1194. Boolean DSeqDoc::DoMenuTask(long tasknum, DTask* theTask)
  1195. {
  1196.     DWindow* win = NULL;
  1197.     
  1198.     switch (tasknum) {
  1199.     
  1200.         case cNewSeq        : 
  1201.             AddNewSeqToList(); 
  1202.             //fall into EditSeqs
  1203.         case cEditSeq: 
  1204.             EditSeqs(); 
  1205.             return true;
  1206.  
  1207.         case cSaveSel:
  1208.             fSaveSelection= true;
  1209.             gApplication->DoMenuTask( DApplication::kSaveACopy, NULL);
  1210.             fSaveSelection= false;
  1211.             return true;
  1212.  
  1213.         case cRevert:
  1214.             Revert();
  1215.             return true;
  1216.             
  1217.         case cFindORF: 
  1218.             FindORF();
  1219.             return true;
  1220.             
  1221.         case cConsensus:
  1222.             MakeConsensus();
  1223.             return true;
  1224.  
  1225.         case cDistance:
  1226.             DistanceMatrix(fgMatKind);
  1227.             return true;
  1228.  
  1229.         case cSimilarity:
  1230.             DistanceMatrix(1);
  1231.             return true;
  1232.                     
  1233.     
  1234.         case cRevSeq:
  1235.         case cCompSeq:
  1236.         case cRevCompSeq:
  1237.         case cDna2Rna: 
  1238.         case cRna2Dna:
  1239.         case cToUpper: 
  1240.         case cToLower:
  1241.         case cDegap:
  1242.         case cMaskCompress:
  1243.         case cLockIndels:
  1244.         case cUnlockIndels:
  1245.         case cTranslate:
  1246.             {
  1247.             long    firstBase = 0, nBases = 0;
  1248.             DSeqList * aSeqList= NULL;
  1249.             DSeqChangeCmd *    cmd = NULL;  
  1250.             
  1251.             //fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  1252.             long flags;
  1253.             flags= kIndexSel+kAllIfNone; //+kEqualCount??
  1254.             if (tasknum != cMaskCompress) flags |= kMaskSel|kSeqSel;
  1255.             GetSelection( flags, aSeqList, firstBase, nBases);
  1256.             switch (tasknum) {
  1257.               case cRevSeq        : cmd= new DSeqReverseCmd( this, fAlnView, aSeqList);  break;
  1258.                 case cCompSeq        : cmd= new DSeqComplementCmd( this, fAlnView,aSeqList); break;
  1259.                 case cRevCompSeq: cmd= new DSeqRevComplCmd( this, fAlnView,aSeqList); break;
  1260.                 case cDna2Rna        : cmd= new DSeqDna2RnaCmd( this, fAlnView,aSeqList); break;
  1261.                 case cRna2Dna        :    cmd= new DSeqRna2DnaCmd( this, fAlnView,aSeqList); break;
  1262.                 case cToUpper        :    cmd= new DSeqUppercaseCmd( this, fAlnView,aSeqList); break;
  1263.                 case cToLower        :    cmd= new DSeqLowercaseCmd( this,fAlnView, aSeqList); break;
  1264.                 case cDegap            :    cmd= new DSeqCompressCmd( this, fAlnView,aSeqList); break;
  1265.                 case cLockIndels:    cmd= new DSeqLockIndelsCmd( this, fAlnView,aSeqList); break;
  1266.                 case cUnlockIndels: cmd= new DSeqUnlockIndelsCmd( this, fAlnView,aSeqList); break;
  1267.                 case cTranslate    :    cmd= new DSeqTranslateCmd( this, fAlnView,aSeqList); break;
  1268.  
  1269.                 case cMaskCompress:    cmd= new DSeqCompressMaskCmd( this, fAlnView,aSeqList); break;
  1270.  
  1271.                 default:
  1272.                     delete aSeqList;
  1273.                     Message(MSG_OK,"DSeqDoc::method not ready.");
  1274.                     return true;
  1275.                 
  1276.               }
  1277.           if (cmd) {
  1278.               if (cmd->Initialize()) PostTask( cmd);
  1279.               else {
  1280.                   // use cmd.fTitle==GetTitle for ::method name !?
  1281.                   Message(MSG_OK,"DSeqDoc::method failed.");
  1282.                   delete cmd; 
  1283.                     }
  1284.               }
  1285.             return true;    
  1286.             }
  1287.  
  1288.         case cPrettyPrint:  MakeSeqPrint( false); return true; //MakeAlnPrint();
  1289.         case cREMap:                MakeSeqPrint( true); return true;
  1290.         case cNAcodes:            NucCodesPicture(); return true;
  1291.         case cAAcodes:            AminoCodesPicture(); return true;
  1292.         case cDotPlot:            //MakeDottyPlot(); return true;
  1293.             Message(MSG_OK,"DSeqDoc::method not ready.");
  1294.             return true;
  1295.  
  1296. #if NETBLAST
  1297.         case cNCBIblast:
  1298.             {
  1299.             char* blastProgram = "blastn";
  1300.             char* blastDatabase = "nr";
  1301.             char* blastOptions = NULL;
  1302.             char* fastaInputFile = "spup-blast-input.fasta";
  1303.             char* outputFile = "spup-blast-result.text";
  1304.             char    instore[128];
  1305.             char  outstore[128];
  1306.             DFile aFile;
  1307.             
  1308.             fastaInputFile= DFileManager::TempFilename( instore);
  1309.             outputFile= DFileManager::TempFilename( outstore);
  1310.  
  1311.             short nseq= SelectionToFile( false, fastaInputFile, DSeqFile::kPearson);
  1312.             if (nseq) {
  1313.                 short err= CallNCBIBlastService(blastProgram, blastDatabase, blastOptions, 
  1314.                                                         fastaInputFile, outputFile);
  1315.  
  1316.                 if (err) {
  1317.                     Message(MSG_OK,"DSeqDoc::CallNCBIBlastService error %d", err);
  1318.                     }
  1319.                 else {
  1320.                     DRichTextDoc* doc= new DRichTextDoc(0,  true, gTextFont);
  1321.                     doc->Open(outputFile);
  1322.                     aFile.Initialize(outputFile);
  1323.                     aFile.Delete();
  1324.                     }
  1325.                  }
  1326.             aFile.Initialize(fastaInputFile);
  1327.             aFile.Delete();
  1328.             }
  1329.             return true;
  1330.             
  1331. #else        
  1332.         case cNCBIblast:
  1333. #endif
  1334.     
  1335.         case cGrailSearch:
  1336.         case cGeneidSearch:
  1337.       case cFHCRCblocks:
  1338.       case cEMBLfasta:
  1339.       case cEMBLblitz:
  1340.       case cEMBLquicks:
  1341.             {
  1342.             DSequence* aSeq= fAlnView->SelectedSequence();
  1343.             if (aSeq) {
  1344.                 switch (tasknum) {
  1345.                     case cNCBIblast: win= new DNCBIBlast(0, this, aSeq); break;
  1346.                      case cEMBLblitz: win= new DEMBLBlitz(0, this, aSeq); break;
  1347.                      case cEMBLfasta: win= new DEMBLFasta(0, this, aSeq); break;
  1348.                      case cEMBLquicks: win= new DEMBLQuicks(0, this, aSeq); break;
  1349.                      case cFHCRCblocks: win= new DFHCRCblocks(0, this, aSeq); break;
  1350.                      case cGeneidSearch: win= new DUWFGeneID(0, this, aSeq); break;
  1351.                      case cGrailSearch: win= new DORNLGrail(0, this, aSeq); break;
  1352.                     }
  1353.                 if (win) win->Open();
  1354.                 }
  1355.             return true;
  1356.             }
  1357.  
  1358.       case cFHCRCfetch:
  1359.         case cEMBLfetch:
  1360.         case cNCBIfetch:
  1361.             switch (tasknum) {
  1362.                 case cNCBIfetch: win= new DNCBIFetch(0, this); break;
  1363.                  case cEMBLfetch: win= new DEMBLFetch(0, this); break;
  1364.                  case cFHCRCfetch: win= new DFHCRCfetch(0, this); break;
  1365.                 }
  1366.             if (win) win->Open();
  1367.             return true;
  1368.                         
  1369.         case cGenmarkSearch:
  1370.         case cPythiaSearch:
  1371.             Message(MSG_OK,"DSeqDoc::method not ready.");
  1372.             return true;
  1373.  
  1374.  
  1375.         default: 
  1376.             return DTaskMaster::DoMenuTask(tasknum, theTask);
  1377.         }
  1378.  
  1379. }
  1380.  
  1381.  
  1382. Boolean DSeqDoc::IsMyAction(DTaskMaster* action) 
  1383. {
  1384.     enum appMenus { kInternetMenu = 100, kPrefsMenu, kOpenMenu };  // HACK ! from SeqPup.cpp
  1385.     long  menuid= 0, menuitem = action->Id();
  1386.     if (action->fSuperior) menuid = action->fSuperior->Id();
  1387.     
  1388.     if ( menuid == DApplication::cEditMenu
  1389.         && HasEditText() && fEditText == fAlnView->fEditSeq ) {
  1390.         if (fEditText->IsMyAction( action)) return true;
  1391.         }
  1392.         
  1393.     //if (menuid == DApplication::cEditMenu)  
  1394.     
  1395.     if ((menuid == kInternetMenu
  1396.         ||menuid == DSeqApps::kChildMenu)
  1397.      && (menuitem >= DSeqApps::kChildMenuBaseID 
  1398.          && menuitem <= DSeqApps::kChildMenuBaseID + 50) // +50 = HACK !! need better way to distinguish menu items !
  1399.     ) goto caseChildMenu;
  1400.         
  1401.     switch (menuitem) {
  1402.     
  1403.         case DApplication::kCut:
  1404.         case DApplication::kCopy:
  1405.         case DApplication::kClear:
  1406.           {
  1407.             DAlnEditCommand* cmd= new DAlnEditCommand(this, menuitem);
  1408.             PostTask( cmd);
  1409.             return true;            
  1410.             }
  1411.         
  1412.         case DApplication::kPaste:
  1413.             {
  1414.           DView* clipview= (DView*) gClipboardMgr->fClipView; // GetClipView();
  1415.             if (clipview && clipview->fKind == DAlnView::kindAlnView) {
  1416.                 DAlnPasteCommand* cmd= new DAlnPasteCommand(this);
  1417.                 PostTask( cmd);
  1418.                 return true;            
  1419.                 }
  1420.             else if (HasEditText()) {  /* && clipview->fKind == OStype("TEXT") */
  1421.                 if (fEditText->IsMyAction(action)) return true;
  1422.                 }
  1423.             return true; //?? always handle this message?
  1424.             }
  1425.             
  1426.         case DApplication::kSelectAll:
  1427.             if (fAlnIndex) {
  1428.             Nlm_RecT r;
  1429.             Nlm_LoadRect(& r, 0, 0, 1/*fAlnIndex->GetMaxCols()*/, fAlnIndex->GetMaxRows());
  1430.             fAlnIndex->SelectCells( r);
  1431.             return true;            
  1432.             }
  1433.  
  1434.         }
  1435.  
  1436.     if (menuid == kViewKindMenu)  
  1437.      switch (menuitem) {
  1438.             case kViewByDefault:
  1439.                     this->SortView(DSeqList::kSortByItem); return true;
  1440.             case kViewByDate:
  1441.                     this->SortView(DSeqList::kSortByDate); return true;
  1442.             case kViewBySize:
  1443.                     this->SortView(DSeqList::kSortBySize); return true;
  1444.             case kViewByName:
  1445.                     this->SortView(DSeqList::kSortByName); return true;
  1446.             case kViewByKind:
  1447.                     this->SortView(DSeqList::kSortByKind); return true;
  1448.             case kViewAsText:
  1449.                     this->ToTextDoc(); return true;
  1450.             default: return true;
  1451.             }
  1452.  
  1453.     else if (menuid == kSeqMaskMenu && fAlnView->fMaskLevel>0) {
  1454.         if (menuitem == cMaskCompress) 
  1455.             return DoMenuTask(menuitem, NULL);
  1456.         else
  1457.             return fAlnView->MaskCommand( menuitem);
  1458.         }
  1459.  
  1460.     else if (menuid == DSeqApps::kChildMenu) {
  1461.     caseChildMenu:
  1462.         switch (menuitem) {
  1463. #if 0
  1464.             case cAddChildCmd:
  1465.             case cRemoveChildCmd:  
  1466.                 DoMenuTask(menuitem);
  1467.                 break;
  1468. #endif    
  1469.             default:
  1470.                 {
  1471.                 long    firstBase = 0, nBases = 0;
  1472.                 DSeqList * aSeqList= NULL;
  1473.                 //fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  1474.                 GetSelection( kSeqSel+kMaskSel+kIndexSel+kAllIfNone, //+kEqualCount ??
  1475.                                 aSeqList, firstBase, nBases);
  1476.                 DSeqApps::CallChildApp( menuitem, aSeqList);
  1477.                 if (aSeqList) delete aSeqList;
  1478.                 }
  1479.                 break;
  1480.             }
  1481.         }
  1482.         
  1483.     else if (menuitem == kColorPopup) {
  1484.         fgUseColor= fColorPop->GetValue();
  1485.         fAlnView->SetViewColor( fgUseColor);
  1486.         //fAlnView->Invalidate();
  1487.       return true;
  1488.         }
  1489.  
  1490.     else if (menuitem == kLockButHit) {
  1491.         fAlnView->SetTextLock( ((DView*)action)->GetStatus());
  1492.       return true;
  1493.       }
  1494.  
  1495.     else if (menuitem == kModePopup) {
  1496.         short mode= fModePop->GetValue();  
  1497.         fAlnView->SetViewMode( mode);
  1498.       return true;
  1499.       }
  1500.     
  1501.     else 
  1502.         return DoMenuTask(menuitem, NULL);
  1503.         
  1504.     return false;
  1505. }
  1506.             
  1507.  
  1508.  
  1509.  
  1510.